home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_gc.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  15.9 KB  |  606 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. from test.test_support import verify, verbose, TestFailed, vereq
  5. import sys
  6. import gc
  7. import weakref
  8.  
  9. def expect(actual, expected, name):
  10.     if actual != expected:
  11.         raise TestFailed, 'test_%s: actual %r, expected %r' % (name, actual, expected)
  12.     
  13.  
  14.  
  15. def expect_nonzero(actual, name):
  16.     if actual == 0:
  17.         raise TestFailed, 'test_%s: unexpected zero' % name
  18.     
  19.  
  20.  
  21. def run_test(name, thunk):
  22.     if verbose:
  23.         print 'testing %s...' % name,
  24.     
  25.     thunk()
  26.     if verbose:
  27.         print 'ok'
  28.     
  29.  
  30.  
  31. def test_list():
  32.     l = []
  33.     l.append(l)
  34.     gc.collect()
  35.     del l
  36.     expect(gc.collect(), 1, 'list')
  37.  
  38.  
  39. def test_dict():
  40.     d = { }
  41.     d[1] = d
  42.     gc.collect()
  43.     del d
  44.     expect(gc.collect(), 1, 'dict')
  45.  
  46.  
  47. def test_tuple():
  48.     l = []
  49.     t = (l,)
  50.     l.append(t)
  51.     gc.collect()
  52.     del t
  53.     del l
  54.     expect(gc.collect(), 2, 'tuple')
  55.  
  56.  
  57. def test_class():
  58.     
  59.     class A:
  60.         pass
  61.  
  62.     A.a = A
  63.     gc.collect()
  64.     del A
  65.     expect_nonzero(gc.collect(), 'class')
  66.  
  67.  
  68. def test_newstyleclass():
  69.     
  70.     class A(object):
  71.         pass
  72.  
  73.     gc.collect()
  74.     del A
  75.     expect_nonzero(gc.collect(), 'staticclass')
  76.  
  77.  
  78. def test_instance():
  79.     
  80.     class A:
  81.         pass
  82.  
  83.     a = A()
  84.     a.a = a
  85.     gc.collect()
  86.     del a
  87.     expect_nonzero(gc.collect(), 'instance')
  88.  
  89.  
  90. def test_newinstance():
  91.     
  92.     class A(object):
  93.         pass
  94.  
  95.     a = A()
  96.     a.a = a
  97.     gc.collect()
  98.     del a
  99.     expect_nonzero(gc.collect(), 'newinstance')
  100.     
  101.     class B(list):
  102.         pass
  103.  
  104.     
  105.     class C(B, A):
  106.         pass
  107.  
  108.     a = C()
  109.     a.a = a
  110.     gc.collect()
  111.     del a
  112.     expect_nonzero(gc.collect(), 'newinstance(2)')
  113.     del B
  114.     del C
  115.     expect_nonzero(gc.collect(), 'newinstance(3)')
  116.     A.a = A()
  117.     del A
  118.     expect_nonzero(gc.collect(), 'newinstance(4)')
  119.     expect(gc.collect(), 0, 'newinstance(5)')
  120.  
  121.  
  122. def test_method():
  123.     
  124.     class A:
  125.         
  126.         def __init__(self):
  127.             self.init = self.__init__
  128.  
  129.  
  130.     a = A()
  131.     gc.collect()
  132.     del a
  133.     expect_nonzero(gc.collect(), 'method')
  134.  
  135.  
  136. def test_finalizer():
  137.     
  138.     class A:
  139.         
  140.         def __del__(self):
  141.             pass
  142.  
  143.  
  144.     
  145.     class B:
  146.         pass
  147.  
  148.     a = A()
  149.     a.a = a
  150.     id_a = id(a)
  151.     b = B()
  152.     b.b = b
  153.     gc.collect()
  154.     del a
  155.     del b
  156.     expect_nonzero(gc.collect(), 'finalizer')
  157.     for obj in gc.garbage:
  158.         if id(obj) == id_a:
  159.             del obj.a
  160.             break
  161.             continue
  162.     else:
  163.         raise TestFailed, "didn't find obj in garbage (finalizer)"
  164.     gc.garbage.remove(obj)
  165.  
  166.  
  167. def test_finalizer_newclass():
  168.     
  169.     class A(object):
  170.         
  171.         def __del__(self):
  172.             pass
  173.  
  174.  
  175.     
  176.     class B(object):
  177.         pass
  178.  
  179.     a = A()
  180.     a.a = a
  181.     id_a = id(a)
  182.     b = B()
  183.     b.b = b
  184.     gc.collect()
  185.     del a
  186.     del b
  187.     expect_nonzero(gc.collect(), 'finalizer')
  188.     for obj in gc.garbage:
  189.         if id(obj) == id_a:
  190.             del obj.a
  191.             break
  192.             continue
  193.     else:
  194.         raise TestFailed, "didn't find obj in garbage (finalizer)"
  195.     gc.garbage.remove(obj)
  196.  
  197.  
  198. def test_function():
  199.     d = { }
  200.     exec 'def f(): pass\n' in d
  201.     gc.collect()
  202.     del d
  203.     expect(gc.collect(), 2, 'function')
  204.  
  205.  
  206. def test_frame():
  207.     
  208.     def f():
  209.         frame = sys._getframe()
  210.  
  211.     gc.collect()
  212.     f()
  213.     expect(gc.collect(), 1, 'frame')
  214.  
  215.  
  216. def test_saveall():
  217.     gc.collect()
  218.     vereq(gc.garbage, [])
  219.     L = []
  220.     L.append(L)
  221.     id_L = id(L)
  222.     debug = gc.get_debug()
  223.     gc.set_debug(debug | gc.DEBUG_SAVEALL)
  224.     del L
  225.     gc.collect()
  226.     gc.set_debug(debug)
  227.     vereq(len(gc.garbage), 1)
  228.     obj = gc.garbage.pop()
  229.     vereq(id(obj), id_L)
  230.  
  231.  
  232. def test_del():
  233.     thresholds = gc.get_threshold()
  234.     gc.enable()
  235.     gc.set_threshold(1)
  236.     
  237.     class A:
  238.         
  239.         def __del__(self):
  240.             dir(self)
  241.  
  242.  
  243.     a = A()
  244.     del a
  245.     gc.disable()
  246.     gc.set_threshold(*thresholds)
  247.  
  248.  
  249. def test_del_newclass():
  250.     thresholds = gc.get_threshold()
  251.     gc.enable()
  252.     gc.set_threshold(1)
  253.     
  254.     class A(object):
  255.         
  256.         def __del__(self):
  257.             dir(self)
  258.  
  259.  
  260.     a = A()
  261.     del a
  262.     gc.disable()
  263.     gc.set_threshold(*thresholds)
  264.  
  265.  
  266. class Ouch:
  267.     n = 0
  268.     
  269.     def __del__(self):
  270.         Ouch.n = Ouch.n + 1
  271.         if Ouch.n % 17 == 0:
  272.             gc.collect()
  273.         
  274.  
  275.  
  276.  
  277. def test_trashcan():
  278.     gc.enable()
  279.     N = 150
  280.     for count in range(2):
  281.         t = []
  282.         for i in range(N):
  283.             t = [
  284.                 t,
  285.                 Ouch()]
  286.         
  287.         u = []
  288.         for i in range(N):
  289.             u = [
  290.                 u,
  291.                 Ouch()]
  292.         
  293.         v = { }
  294.         for i in range(N):
  295.             v = {
  296.                 1: v,
  297.                 2: Ouch() }
  298.         
  299.     
  300.     gc.disable()
  301.  
  302.  
  303. class Boom:
  304.     
  305.     def __getattr__(self, someattribute):
  306.         del self.attr
  307.         raise AttributeError
  308.  
  309.  
  310.  
  311. def test_boom():
  312.     a = Boom()
  313.     b = Boom()
  314.     a.attr = b
  315.     b.attr = a
  316.     gc.collect()
  317.     garbagelen = len(gc.garbage)
  318.     del a
  319.     del b
  320.     expect(gc.collect(), 4, 'boom')
  321.     expect(len(gc.garbage), garbagelen, 'boom')
  322.  
  323.  
  324. class Boom2:
  325.     
  326.     def __init__(self):
  327.         self.x = 0
  328.  
  329.     
  330.     def __getattr__(self, someattribute):
  331.         self.x += 1
  332.         if self.x > 1:
  333.             del self.attr
  334.         
  335.         raise AttributeError
  336.  
  337.  
  338.  
  339. def test_boom2():
  340.     a = Boom2()
  341.     b = Boom2()
  342.     a.attr = b
  343.     b.attr = a
  344.     gc.collect()
  345.     garbagelen = len(gc.garbage)
  346.     del a
  347.     del b
  348.     expect(gc.collect(), 4, 'boom2')
  349.     expect(len(gc.garbage), garbagelen, 'boom2')
  350.  
  351.  
  352. class Boom_New(object):
  353.     
  354.     def __getattr__(self, someattribute):
  355.         del self.attr
  356.         raise AttributeError
  357.  
  358.  
  359.  
  360. def test_boom_new():
  361.     a = Boom_New()
  362.     b = Boom_New()
  363.     a.attr = b
  364.     b.attr = a
  365.     gc.collect()
  366.     garbagelen = len(gc.garbage)
  367.     del a
  368.     del b
  369.     expect(gc.collect(), 4, 'boom_new')
  370.     expect(len(gc.garbage), garbagelen, 'boom_new')
  371.  
  372.  
  373. class Boom2_New(object):
  374.     
  375.     def __init__(self):
  376.         self.x = 0
  377.  
  378.     
  379.     def __getattr__(self, someattribute):
  380.         self.x += 1
  381.         if self.x > 1:
  382.             del self.attr
  383.         
  384.         raise AttributeError
  385.  
  386.  
  387.  
  388. def test_boom2_new():
  389.     a = Boom2_New()
  390.     b = Boom2_New()
  391.     a.attr = b
  392.     b.attr = a
  393.     gc.collect()
  394.     garbagelen = len(gc.garbage)
  395.     del a
  396.     del b
  397.     expect(gc.collect(), 4, 'boom2_new')
  398.     expect(len(gc.garbage), garbagelen, 'boom2_new')
  399.  
  400.  
  401. def test_get_referents():
  402.     alist = [
  403.         1,
  404.         3,
  405.         5]
  406.     got = gc.get_referents(alist)
  407.     got.sort()
  408.     expect(got, alist, 'get_referents')
  409.     atuple = tuple(alist)
  410.     got = gc.get_referents(atuple)
  411.     got.sort()
  412.     expect(got, alist, 'get_referents')
  413.     adict = {
  414.         1: 3,
  415.         5: 7 }
  416.     expected = [
  417.         1,
  418.         3,
  419.         5,
  420.         7]
  421.     got = gc.get_referents(adict)
  422.     got.sort()
  423.     expect(got, expected, 'get_referents')
  424.     got = gc.get_referents([
  425.         1,
  426.         2], {
  427.         3: 4 }, (0, 0, 0))
  428.     got.sort()
  429.     expect(got, [
  430.         0,
  431.         0] + range(5), 'get_referents')
  432.     expect(gc.get_referents(1, 'a', (0.0+4.0j)), [], 'get_referents')
  433.  
  434.  
  435. class C1055820(object):
  436.     
  437.     def __init__(self, i):
  438.         self.i = i
  439.         self.loop = self
  440.  
  441.  
  442.  
  443. class GC_Detector(object):
  444.     
  445.     def __init__(self):
  446.         self.gc_happened = False
  447.         
  448.         def it_happened(ignored):
  449.             self.gc_happened = True
  450.  
  451.         self.wr = weakref.ref(C1055820(666), it_happened)
  452.  
  453.  
  454.  
  455. def test_bug1055820b():
  456.     ouch = []
  457.     
  458.     def callback(ignored):
  459.         ouch[:] = [ wr() for wr in WRs ]
  460.  
  461.     Cs = [ C1055820(i) for i in range(2) ]
  462.     WRs = [ weakref.ref(c, callback) for c in Cs ]
  463.     c = None
  464.     gc.collect()
  465.     expect(len(ouch), 0, 'bug1055820b')
  466.     Cs = None
  467.     gc.collect()
  468.     expect(len(ouch), 2, 'bug1055820b')
  469.     for x in ouch:
  470.         expect(x, None, 'bug1055820b')
  471.     
  472.  
  473.  
  474. def test_bug1055820c():
  475.     c0 = C1055820(0)
  476.     gc.collect()
  477.     c1 = C1055820(1)
  478.     c1.keep_c0_alive = c0
  479.     del c0.loop
  480.     c2 = C1055820(2)
  481.     c2wr = weakref.ref(c2)
  482.     ouch = []
  483.     
  484.     def callback(ignored):
  485.         ouch[:] = [
  486.             c2wr()]
  487.  
  488.     c0wr = weakref.ref(c0, callback)
  489.     c0 = None
  490.     c1 = None
  491.     c2 = None
  492.     junk = []
  493.     i = 0
  494.     detector = GC_Detector()
  495.     while not detector.gc_happened:
  496.         i += 1
  497.         if i > 10000:
  498.             raise TestFailed("gc didn't happen after 10000 iterations")
  499.         
  500.         expect(len(ouch), 0, 'bug1055820c')
  501.         junk.append([])
  502.     expect(len(ouch), 1, 'bug1055820c')
  503.     for x in ouch:
  504.         expect(x, None, 'bug1055820c')
  505.     
  506.  
  507.  
  508. def test_bug1055820d():
  509.     ouch = []
  510.     
  511.     class D(C1055820):
  512.         
  513.         def __del__(self):
  514.             ouch[:] = [
  515.                 c2wr()]
  516.  
  517.  
  518.     d0 = D(0)
  519.     gc.collect()
  520.     c1 = C1055820(1)
  521.     c1.keep_d0_alive = d0
  522.     del d0.loop
  523.     c2 = C1055820(2)
  524.     c2wr = weakref.ref(c2)
  525.     d0 = None
  526.     c1 = None
  527.     c2 = None
  528.     detector = GC_Detector()
  529.     junk = []
  530.     i = 0
  531.     while not detector.gc_happened:
  532.         i += 1
  533.         if i > 10000:
  534.             raise TestFailed("gc didn't happen after 10000 iterations")
  535.         
  536.         expect(len(ouch), 0, 'bug1055820d')
  537.         junk.append([])
  538.     expect(len(ouch), 1, 'bug1055820d')
  539.     for x in ouch:
  540.         expect(x, None, 'bug1055820d')
  541.     
  542.  
  543.  
  544. def test_all():
  545.     gc.collect()
  546.     run_test('lists', test_list)
  547.     run_test('dicts', test_dict)
  548.     run_test('tuples', test_tuple)
  549.     run_test('classes', test_class)
  550.     run_test('new style classes', test_newstyleclass)
  551.     run_test('instances', test_instance)
  552.     run_test('new instances', test_newinstance)
  553.     run_test('methods', test_method)
  554.     run_test('functions', test_function)
  555.     run_test('frames', test_frame)
  556.     run_test('finalizers', test_finalizer)
  557.     run_test('finalizers (new class)', test_finalizer_newclass)
  558.     run_test('__del__', test_del)
  559.     run_test('__del__ (new class)', test_del_newclass)
  560.     run_test('saveall', test_saveall)
  561.     run_test('trashcan', test_trashcan)
  562.     run_test('boom', test_boom)
  563.     run_test('boom2', test_boom2)
  564.     run_test('boom_new', test_boom_new)
  565.     run_test('boom2_new', test_boom2_new)
  566.     run_test('get_referents', test_get_referents)
  567.     run_test('bug1055820b', test_bug1055820b)
  568.     gc.enable()
  569.     
  570.     try:
  571.         run_test('bug1055820c', test_bug1055820c)
  572.     finally:
  573.         gc.disable()
  574.  
  575.     gc.enable()
  576.     
  577.     try:
  578.         run_test('bug1055820d', test_bug1055820d)
  579.     finally:
  580.         gc.disable()
  581.  
  582.  
  583.  
  584. def test():
  585.     if verbose:
  586.         print 'disabling automatic collection'
  587.     
  588.     enabled = gc.isenabled()
  589.     gc.disable()
  590.     verify(not gc.isenabled())
  591.     debug = gc.get_debug()
  592.     gc.set_debug(debug & ~(gc.DEBUG_LEAK))
  593.     
  594.     try:
  595.         test_all()
  596.     finally:
  597.         gc.set_debug(debug)
  598.         gc.enable()
  599.         verify(gc.isenabled())
  600.         if not enabled:
  601.             gc.disable()
  602.         
  603.  
  604.  
  605. test()
  606.